import org.junit.jupiter.api.Test;

import java.util.Arrays;

/**
 * 数组 Array
 * 数组相当于一堆相同数据类型的数据；
 */
public class 数组 {
    @Test
    public void testArray(){
        //注意：数组定义长度，不能改变
        int[]  arr1=new  int[4];//Java推荐写法  动态初始化
        int arr2[]=new int[4];//C推荐写法Java兼容 动态初始化
        int[] arr3={1,2,3,4,5,6,7,8,9};//静态初始化数组，元素可以直接使用
        int[] arr4=new int[]{100,80,60};//动态初始化
        //数组：内部存数据叫做元素
        //从arr3取出2的元素
        System.out.println(arr3[1]);
        System.out.println(arr4[2]);
        //从arr3的长度
        System.out.println(arr3.length);
        //从arr4获取到  第四个元素值       数组下标越线异常：下标超出数组长度范围
        System.out.println();//报错java.lang.ArrayIndexOutOfBoundsException: 4

    }
    /**
     * 数组的迭代(遍历：输出数组所有元素的值)三种
     * 1.普通迭代方式：for
     * 2.增强for方式：推荐JDK1.5之后
     * 3.工具类：Arrays
     */
    @Test
    public void testIterate(){
        int[]  arr={1,2,3,4,5,6};//静态初始化数据    数组名[下标]
//        for(int i=0;i<arr.length;i++){   //拿数组下标
//            System.out.println(arr[i]);
//        }
        //增强for  jdk 1.5    遍历数据目的：拿元素值
//        for(int j:arr){
//            System.out.println(j);}
//        int[]  arr1={1,11,1111,11111,1111111,11111111};
//        for(int z=0;z<arr1.length;z++){
//            System.out.println(arr1[z]);
//        }
//        int[] arr2=new  int[6];
//        for(int g=0;g<arr2.length;g++){
//            System.out.println(arr2[g]);
//        }
        //工具类：Arrays.toString()直接打印数据元素值
        System.out.println(Arrays.toString(arr));
    }
    /**
     * 数组扩容：数组长度是固定的，不可改变【可以使用扩容改变数组长度】
     */
     @Test
    public  void testCopy(){
         //字符数组
         char[] arr={'唐','山'};  //想法：长度增加为4
         //扩容：增加为4
         char[] temp=Arrays.copyOf(arr,8);
         arr=temp;
//         System.out.println(arr);
//         System.out.println(arr.length);
         arr[2]='工';
         arr[3]='业';
         arr[4]='顾';
         arr[5]='涵';

//         char[] temp1=Arrays.copyOf(arr1,4);

         System.out.println(arr);


     }
    /**
     * 数组输出元素时，会有一些不同，【查看数据是否是数组】
     * 数据类型：基础数据类型+引用类型
     */
    @Test
    public void testArrays(){
        //字符数组
        char[] china={'中','国'};
        System.out.println(china);//输出：中国   字符串：字符数值
        //输出语句--JavaOOP面向对象：重载，字符数组自动重载
        //数值数组
        int[] i={1,2};
        System.out.println(i);//输出：[I数据类型  @  连接符   70a9f84e地址值

    }
    /**
     * 冒泡排序：双层for循环的使用：外层for执行一次，内层执行全部
     */
    @Test
    public void bubbleSort(){
        //静态初始化数组
        int[]  arr={3,6,1,4};
        //①外层for
        for(int i=0;i<arr.length-1;i++){
            //②内层for控制次 j= 3轮递减-[3-1]次
            for(int j=0;j<arr.length-1-i;j++){
                //③交换：第一个元素比第二个元素大，条件成立：交换【升序】
                if(arr[j]>arr[j+1]){//【相邻元素】数组名[下标]
                    //创建一个第三方数组,接收   变量名：temp
                    int  temp=arr[j];//大的元素交给第三方变量保存
                    arr[j]=arr[j+1];//第二个元素换给第一个元素位置
                    arr[j+1]=temp;//保存第三方变量【大数】交给第二个元素


                }
            }

        }
        System.out.println(Arrays.toString(arr));//输出数组【遍历数组】
    }
    @Test
    public void testSort(){
        int[] arr={3,6,4,1};
        //工具类Arrays.sort()方法排序  默认升序
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));
    }

}

